package com.otherTest.sort;


import org.junit.Test;

/**
 * 冒泡排序算法
 * 要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，
 * 让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。
 *
 * @author Conceit
 * @version 1.0, 2017/3/20
 */
public class BubbleSort {

    @Test
    public void bubbleSort() {
        int sort[] = {6, 1, 11, 7, 9, 3, 4, 5, 10, 8, 2};

        if (sort.length == 0) {
            System.out.println("数组内暂无数据！");
            return;
        }
        //11
        System.out.println(sort.length);
        //10
        System.out.println(sort.length - 1);

        int temp = 0;
        //循环的次数
        for (int i = 0; i < sort.length - 1; i++) {
            //每趟排序多少次 排序范围不断缩小
            for (int y = 0; y < sort.length - i - 1; y++) {
                //数值交换 每次与下一个下标的值进行比较
                if (sort[y] > sort[y + 1]) {
                    temp = sort[y];
                    //核心交换
                    sort[y] = sort[y + 1];
                    sort[y + 1] = temp;
                }

            }

        }


        if (sort.length != 0) {
            for (int i : sort) {
                System.out.println(i);
            }
        }

    }


    //////////////////新测试代码
    @Test
    public void bubbleSort2() {
        int sort[] = {6, 1, 11, 7, 9, 3, 4, 5, 10, 8, 2};

        if (sort.length == 0) {
            System.out.println("数组内暂无数据！");
            return;
        }

        int temp = 0;
        //11
        //System.out.println(sort.length);
        //迭代数组 需要迭代两遍 外循环控制迭代的次数
        for (int start = 0; start < sort.length - 1; start++) {
            //每趟排序多少次 排序范围不断缩小
            for (int start2 = 0; start2 < sort.length - 1 - start; start2++) {
                //System.out.println(sort[start]);
                //若后值小于前值
                if (sort[start2] > sort[start2 + 1]) {
                    //后值放入局部变量
                    temp = sort[start2 + 1];
                    //前后值交换
                    sort[start2 + 1] = sort[start2];
                    //局部变量赋值给前值
                    sort[start2] = temp;


                }
            }

        }
        for (Integer i : sort) {
            System.out.println(i);
        }
    }

    //实现
    @Test
    public void bubbleSort3() {
        int[] sort = {1, 2, 11, 0};

        if (sort.length == 0 || sort == null) {
            System.out.println("该数组不可用!");
            return;
        }
        System.out.println("该数组的index为:" + sort.length);

        int temp = 0;
        //防止最后一个下标溢出 控制循环次数
        for (int i = 0; i < sort.length - 1; i++) {
            System.out.println("第一次循环内的sort[i]为:" + sort[i] + "      i为：" + i);
            //每次循环都会将大值 放置结尾下标
            for (int j = 0; j < sort.length - 1 - i; j++) {
                if (sort[j] > sort[j + 1]) {
                    temp = sort[j + 1];
                    sort[j + 1] = sort[j];
                    sort[j] = temp;
                }
            }


        }

        System.out.println("开始打印排序后的数组");
        for (int i : sort) {
            System.out.println(i);
        }
    }

    /**
     * 首先以此遍历数组中的每一个元素，此即为外循环用来控制循环的次数
     * 然后将对应的数组元素与它之后的元素进行比较
     * 如果小于它则调整双方的位置
     * 直到将最大的元素放置最后一个下标位置
     */
    @Test
    public void bubbleSort4() {
        int sort[] = {6, 1, 11, 7, 9, 3, 4, 5, 10, 8, 2};
        //外循环 i<sort.length-1 最后一个下标不在循环
        for (int i = 0; i < sort.length; i++) {
            System.out.println("外循环--->" + sort[i]);
            //内循环j<sort.length-1 防止sort[j+1]判断条件最后一个下表越界
            //-i 为每趟排序多少次 排序范围不断缩小 最大的值以及放到了最后，所以每次最后的数组下标不用在进行比较
            for (int j = 0; j < sort.length - 1 - i; j++) {
                System.out.println("内循环--->" + sort[j]);
                //与之后的每个数值进行比较
                int temp;
                //如果当前的数值下于下一个下标的数值，则进行交换
                if (sort[j] > sort[j + 1]) {
                    //System.out.println(current+"    "+next);
                    temp = sort[j + 1];
                    sort[j + 1] = sort[j];
                    sort[j] = temp;
                }
            }
        }
        for (int s : sort) {
            System.out.println(s);
        }

    }

    @Test
    public int[] bubbleSort5(int[] sort) {
        int[] ints = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8, 2};

        if (sort.length == 0) {
            sort = ints;
        }

        int x;
        for (int i = 0; i < sort.length; i++) {
            //-i会让每次循环的length越来越短，也就是说嵌套循环每次比较的范围会越来越短
            for (int j = 0; j < sort.length - 1 - i; j++) {
                if (sort[j] > sort[j + 1]) {
                    x = sort[j];
                    sort[j] = sort[j + 1];
                    sort[j + 1] = x;
                }
            }
        }
//        for(int s:sort){
////            System.out.println(s);
////        }
        return sort;
    }


    @Test
    public void bubbleSort6() {
        int sort[] = {6, 1, 11, 7, 9, 3, 4, 5, 10, 8, 2};
        System.out.println("sort.length-->" + sort.length);

        for (int i = 0; i < sort.length; i++) {


            for (int j = 0; j < sort.length - 1 - i; j++) {
                int x = sort[j];
                int y = sort[j + 1];
                int temp;
                if (x > y) {
                    temp = x;
                    sort[j] = y;
                    sort[j + 1] = temp;
                }
            }


        }
        System.out.println("遍历完成！");
        for (int s : sort) {
            System.out.println(s);
        }

    }

}
